Systems for allowing annotation in real time

ABSTRACT

Synchronous content sharing of media assets via an object data model propagated through a star network or a mesh network. Each user device updates a local object data model including information on the status of the media asset delivery, to achieve synchronization with the source data. Updates to the local object data model may be the result of direct connection between a user device and an application server via a network, or the result of indirect connections through peers in mesh networks, where the local object data model is shared through hops between peers in the mesh network if the direct connection is unavailable.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a Continuation-in-Part of and claims priority to U.S. patent application Ser. No. 16/105,221, filed Aug. 20, 2018 and titled “Systems for Allowing Annotation in Real Time,” which claims priority to U.S. patent application Ser. No. 14/935,786, filed Nov. 9, 2015 and titled “Systems for Allowing Annotation in Real Time,” which claims priority to U.S. Provisional Patent Application Ser. No. 62/077,006, filed Nov. 7, 2014, the contents of all of which are incorporated herein by reference in their entireties.

TECHNICAL FIELD

The systems and methods described herein relate to network communications. More specifically, the systems and methods described herein relate to the use of network communications to deliver information synchronously to multiple user devices.

BACKGROUND

Sharing synchronized data between users can be a complex process, particularly for computer data. The complexity in part arises from the fact that computer data files can be very large. For example, users and applications commonly want to share audio or video information, text, pictures, games or other media data. Such media data files can be quite large and distributing large data files to multiple users or applications can place unachievable demands on network bandwidth and processing resources.

For example, in a conventional star network, each user establishes a connection with a source server, creating a hub and spoke model for data transfer. U.S. Pat. No. 8,750,305, incorporated by reference in its entirety, describes a star network architecture. Users share audio and video, text and pictures, games or other media assets by transferring data from the hub and across the spokes. In operation, the hub processes requests for data files by transferring the data files to the requestor as quickly as possible. To synchronize the distribution of data, the hub needs to transfer the data to the users quickly enough to have the data appear to arrive at each user at essentially the same 77871126.1 time. Synchronizing data among users presents a unique set of challenges, with the load on the hub network increasing at least proportionally to the number of users.

For example, in the context of a presentation or a conference, with a star network each user establishes a connection with a hub network through a Wi-Fi connection. Each user-to-server connection allows data from transfer from the network to the user, but it also takes up bandwidth and processing resources and gradually impairs the ability of other users to access or access quickly the same data. This negatively impacts certain data transfer applications, such as a streaming media, or a running slide show presentation. In the extreme, some users may be unable to access data due to an inability to connect to the server. This is particularly problematic in classroom or conference settings where participants may wish to follow a presentation in real-time to take notes or interact with colleagues.

As an alternative to star networks, mesh networks have been developed to allow devices to work together to form a mesh and to transfer data from one device to another device via other devices in the mesh network. U.S. Pat. No. 7,710,986, incorporated by reference, describes a mesh network architecture. A mesh network does away with the hub present in the star network, with each connected device in the mesh forming a node. Information can then travel through a combination of nodes, bypassing any broken links or unavailable nodes. Through a mesh device, two devices which are not directly connected can still exchange information through other devices. An example of a mesh network is the Apple Multipeer Connectivity Framework, released in iOS7, which allows nearby iOS devices to communicate with one another even in the absence of common Wi-Fi network.

Mesh networks come with their own set of challenges, including the necessity to keep track of devices available in a mesh network, despite a potentially large number of devices entering, exiting and reentering the mesh network.

As a result, devices within the mesh network frequently use a ping, the sending of a signal to other devices, to determine the number and identity of devices effectively active within the mesh network. In the absence of a response to a ping, the unresponsive device is determined to have left the mesh network, or to at least be unresponsive. As the size of the mesh increases, the transfer of data between nodes, such as sending and receiving pings increases exponentially, creating data noise which is difficult to minimize. Thus, mesh networks can become resource constrained due to the overhead needed to track nodes in the network and the current state of the nodes.

As such, there remains a need for improved systems and methods for accommodating synchronous access by users to data presented by a leader.

SUMMARY

The systems and methods described herein provide systems that set up a first network and an alternate failover network. The first network, in some embodiments, may be a star and hub network and may include nodes that connect directly to a server having the data. Nodes can request data from the server and the requests can be periodically made to synchronize data on the nodes. The system may have a second network that is a failover network. In some implementations the failover network is a mesh network. If a node on the first network determines that a request for data has failed, the node may issue a request for data across the failover network. The failover network may be a mesh network and in this implementation, the node on the mesh network can have an object data model that represents the state of an object data that the nodes are requesting to access.

In one implementation, each node that has an object data model broadcasts across the mesh network that it has an object data model and the state of that object data model. This node is connected to the server through the first network. Nodes on the mesh network can receive the broadcast information and determine which nodes on the mesh network have the most recent object data model. Nodes with older object data models can request data from the nodes with the most recent object data model in order to update their older object data models. Alternatively, each node in a mesh network can check with other nodes in the mesh network, and all such nodes can continuously update their object data models to synchronize to any more recent object data models found on the mesh network. In some implementations, the data being transmitted synchronously through the network is slides in a slide presentation. In this implementation the object data model can include all the slides in the presentation and at least a field indicating the slide currently being presented to the audience. A node can use the object data model to have the slide presented on that respective node be the slide that the most recent object data model indicates is the slide to present.

Typically, the nodes use the first star network to collect information from the server. If the server becomes over burdened with requests from multiple nodes, it may fail to connect to or fail to send data to a node, either at all or in a timely manner for synchronized presentation across the nodes. The node detects the failure and makes the request for the data through the failover network. In this way, in at least some implementations, the system provides synchronous content sharing between a server (a source device) and multiple nodes (user devices), even as resources such as bandwidth and processing power grow scarce. To this end, the systems and methods described herein provide an object data model that stores information regarding the shared content that is stored on the source device. A synchronization module on the source device synchronizes the object data model with an API server. User devices with a local object data model receive updates to the local object data model directly from the API server, or through at least one user device in a mesh network including several user devices. In general, updates to the local object data models are systematic and periodic.

In some examples, a method for synchronous content sharing may comprise the steps of: updating, in a computing device, a source object data model in response to a change in a media asset to yield an updated source object data model, the updated source object data model identifying the media asset to be synchronized and an element of the media asset displayed by the computing device; sending update information from the computing device to a server to cause at least one user device to update a user object data model stored at the at least one user device; and updating the user object data model by pushing updates to the user object data model from the server to the at least one user device.

In some examples, the update information causes the at least one user device to receive and output audio data and a second user device to be prevented from outputting the audio data. The at least one user device may include: a first user device with a first user object data model stored at the first user device; and a second user device with a second user object data model stored at the second user device; and pushing the updates may be performed for all user devices connected to the server. The update information may cause the first user device to distribute audio data generated at the computing device to the second user device and prevent outputting the audio data at the first user device. The method may further comprise: sending the update information from the first user device to the second user device to cause the second user device to update the second user object data model stored at the second user device, the first user device communicatively coupled with the second user device; and updating the second user object data model by periodically pushing the updates to the second user object data model from the first user device. The method may further comprise receiving, at the computing device, a selection of the second user device, wherein the update information includes audio data to be outputted at the second user device, based at least partly on the selection, and prevented from being outputted at the first user device.

In some examples, a computing device for synchronous content sharing comprises: a processor; and a memory configured to store instructions that, when executed by the computing device, cause the computing device to: update, in the computing device, a source object data model in response to a change in a media asset, the source object data model including at least an identification of the media asset to be synchronized and an identification of an active element of the media asset currently displayed by the computing device; send update information from the computing device to a server to cause at least one user device to update a user object data model stored at the at least one user device; and update the user object data model by pushing updates to the user object data model from the server to the at least one user device.

In some examples, the instructions further cause the computing device to generate the source object data model by: extracting data from an application operating on the computing device; presenting an indication of the data from the application; and receiving a user input selecting the indication of the data from the application. Presenting the indication of the data from the application may include presenting a drop down menu listing the data from the application. The instructions may further cause the computing device to generate the source object data model by performing a segmentation process on content stored at or being presented by the computing device. The segmentation process may include dividing the content into a plurality of segments based at least partly on a percent of a visual presentation of the content that changes.

In some examples, a method for synchronous content sharing comprises: updating, in a computing device, a source object data model in response to a change in a media asset; sending the source object data model from the computing device to a server to cause a first user device to update a first user object data model stored at the first user device; updating the first user object data model by pushing the source object data model to the first user device; sending the first user object data model from the first user device to a second user device to cause the second user device to update a second user object data model stored at the second user device; and updating the second user object data model by pushing the first user object data model to the second user device from the first user device.

In some examples, the change in the media asset includes a note generated at the first user device or the second user device and in a note section associated with the media asset. The change in the media asset may include a highlight or an annotation generated at the first user device or the second user device. The change in the media asset may include a question generated at the first user device or the second user device. Updating the source object data model may include generating, at the computing device, a response to the question. The method may further comprise performing a segmentation process on the media asset to divide the media asset into a plurality of segments. Updating the source object data model may include updating a particular segment of the plurality of segments represented by the source object data model. Updating the first user object data model may include updating a particular segment of the plurality of segments represented by the first user object data model; and updating the second user object data model may include updating the particular segment of the plurality of segments represented by the second user object data model. The method may further comprise: detecting a user engagement with the first user object data model or the second user object data model; and sending an indication of the user engagement from the first user device or the second user device to the computing device.

BRIEF DESCRIPTION OF THE DRAWINGS

The characteristics and advantages of an exemplary embodiment are set out in more detail in the following description, made with reference to the accompanying drawings.

FIG. 1 depicts one embodiment of a system described herein;

FIG. 2 depicts a flow chart diagram of one embodiment for synchronizing content described herein;

FIG. 3 depicts a flow chart diagram of one embodiment for synchronizing content described herein;

FIG. 4 depicts a schematic of a star network;

FIG. 5 depicts a schematic of a mesh network;

FIG. 6 depicts a schematic of an embodiment of the system described herein;

FIG. 7 depicts a schematic representation of an exemplary data model structure described herein;

FIG. 8 depicts a schematic of an exemplary embodiment of the system described herein;

FIG. 9 depicts steps for a general request for an object data model according to an exemplary embodiment described herein;

FIG. 10 depicts steps for an object data model request from a mesh network according to an exemplary embodiment described herein;

FIG. 11 depicts steps for a mesh management scheme according to an exemplary embodiment described herein;

FIG. 12 depicts example steps of a method for sharing audio data with a selected user using synchronized content described herein;

FIG. 13 depicts example steps of a method for generating a source object data model for synchronizing content described herein; and

FIG. 14 depicts example steps of a method for synchronizing content described herein.

DETAILED DESCRIPTION OF THE ILLUSTRATED EMBODIMENTS

Objects, advantages, and features of the exemplary embodiment described herein will be apparent to one skilled in the art from a consideration of this specification, including the attached drawings.

It is an object and feature of an exemplary embodiment described herein to provide a robust and reliable way of providing synchronized information to a large number of users. In some settings, multiple users may wish to access on their devices a media asset provided by a source device. For example, conference attendees with tablets may have access to the internet provided by the conference organizer or venue hosts, either through a cellular connection, 3G, 4G, Wi-Fi connection or otherwise. While a presenter talks, moves through the media asset, such as slides of a presentation, a video, or a live demonstration, and annotates it, attendees may want to follow the presentation on their tablet, and want to be able to access the presenter's annotations. For example, doctors attending a medical conference may wish to access a set of slides which a presenter is using.

In some instances, the media asset may be any type of digital content on a computer of a presenter. For instance, an application executing on the computer may access active programs and browser content (e.g., a PowerPoint presentation, a video, a webpage, or any other digital content) on the computer, may categorize the content, and may present the content in a drop-down menu for the presenter to select from to choose which content to broadcast. Once the content is selected for sharing, the application may perform a segmentation process on the content by dividing the content into segments (e.g., slides, video scenes, webpages, etc.) based on measuring a percent of a visual presentation of the content that changes on the screen broadcasting the content. Users may generate user engagement items by annotating or highlighting the segments, taking notes in a note section for the segments and/or asking questions related to the segments. The application may store segment identifiers associated with each segment and track user engagement for the segments (e.g., annotations, highlights, notes, questions, etc.) by, for instance, associating the user engagement items with the segment identifiers. User engagement analytics may be generated by aggregating the annotations, highlights, notes, and/or questions based on their associated segments. User participation analytics may be generated based on the application detecting whether the user is using or is active on a web tab or web portal and/or whether the user leaves the web tab or web portal during a segment. User participation via the web tab or web portal may be tracked and aggregated for individual segments. Audio data (e.g., generated by a microphone at the presenter device during a presentation) may be synced with the content and may also be divided by segment and synched to the corresponding segment. The segmentation process to create segmented content with synchronized segmented audio may occur in real-time and/or be applied to a live broadcast, such as a movie playing, a PowerPoint presentation, or a live demonstration.

To provide an overall understanding of the systems and methods described herein, certain illustrative embodiments will now be described.

As referred to herein, data synchronization or synchronous content sharing means maintaining multiple instances or copies of a dataset in coherence with one another. Data synchronization may use source-synchronous clocking. Data synchronization may occur in real time and requires data extraction from a source, data transfer, data transformation and data loading at the target location. As referred to herein, synchronous or synchronously may be used interchangeably and mean occurring at the same time, or substantially the same time. Data extraction may include extracting active content from a presenter computer and performing a segmentation process on the content by dividing the content into segments (e.g., slides, video scenes, webpages, etc.) based on measuring a percentage of change occurring on the screen broadcasting the content.

As referred to herein, an Application Program Interface (API) server is a set of routines, protocols, and tools for building software applications. The API server specifies how software components should interact and different APIs may be used when programming graphical user interface (GUI) components for different operating systems, applications or websites.

As referred to herein, a computing device means a content source device, and may be a server computing device, which may be located centrally or at distributed locations, and provides services to various types of users and devices connected via a network such as the Internet via network connection 207. The computing device may include a user equipment device, such as user computer equipment, or a wireless user communications device.

As referred to herein, the phrase “user equipment device,” “user equipment,” “user device,” “electronic device,” “electronic equipment,” “media equipment device,” or “media device” should be understood to encompass any device for accessing content, such as a digital storage device, a digital media receiver (DMR), a digital media adapter (DMA), a personal computer (PC), a laptop computer, a tablet computer, a WebTV box, a personal computer television (PC/TV), a PC media server, a PC media center, a hand-held computer, a stationary telephone, a personal digital assistant (PDA), a mobile telephone, a portable video player, a smart phone, or any other television equipment, computing equipment, or wireless device, and/or combination of the same.

User equipment devices can be implemented as user computer equipment, wireless user communications device, or any other type of user equipment suitable for accessing content, such as a non-portable gaming machine. For simplicity, these devices may be referred to herein collectively as user equipment or user equipment devices. User equipment devices, on which an application may be implemented, may function as a standalone device or may be part of a network of devices. Various network configurations of devices may be implemented.

As referred to herein, an object data model includes an object based logical model: a data model based on object-oriented programming including objects and object identifiers. An object data model, also referred to as data model, may be an object oriented structure which may describe a wide range of media assets by storing different classes with different properties, and forming an organized hierarchy. Fields within the object data model may be set to describe the nature, status, or overall properties of a media asset. In the object data model an object has a state and a behavior.

The object data model may include fields used to synchronize the display of slides for users with the slides as displayed by the presenter. For example, the object data model may include structural information such as media asset identification, categories, headers, fields. The data model may include core information, such as number of slides or intended order of the slides, as well as temporal information, such as an active slide flag or an upcoming flag slide. Finally, the data model may include managing instructions on how to use data from the different data fields in the data model in conjunction with one another to determine the status of the media asset stored.

An object state may be a set of values for the attributes of the object. Each object is represented by an object data structure that includes a plurality of fields (attributes) into which is stored useful information that describes characteristics of the corresponding object. The fields (attributes) of a given object may be used to encapsulate data and/or link to software functionality and/or processes pertinent to the given object. For example, the fields of a given object may include a pointer to a data link mechanism that enables access to the data for the given object as is well known in the art. An object behavior is program code which operates on the state of the object, written in a general purpose programming language which manipulates the object's local instance variables and may send messages to other objects. An object data model may be stored in a database which may be stored locally or remotely.

As referred herein, the term “in response to” refers to initiated as a result of For example, a first action being performed in response to another action may include interstitial steps between the first action and the second action. As referred herein, the term “directly in response to” refers to caused by. For example, a first action being performed directly in response to another action may not include interstitial steps between the first action and the second action.

In the embodiment shown in FIG. 1, system 100 includes a computing device 110, control circuitry 107, processing circuitry 106, storage 108, an object data model 112, a user input interface 102, a display 104, a network connection 114, an API server 122, a user device 116 and a user device 118 in mesh network 120. In this embodiment, content is synchronously shared between the computing device 110 and the user devices 116 and 118.

In the embodiment of FIG. 1, a presenter using computing device 110 shares data, such as a set of slides generated for display on display 104. The computing device 110 may be a computer or tablet provided by the presenter, the conference organizers, or another party.

Display 104 may be one or more of a monitor, a television, a liquid crystal display (LCD) for a mobile device, amorphous silicon display, low temperature poly silicon display, electronic ink display, electrophoretic display, active matrix display, electro-wetting display, electrofluidic display, cathode ray tube display, light-emitting diode display, electroluminescent display, plasma display panel, high-performance addressing display, thin-film transistor display, organic light-emitting diode display, surface-conduction electron-emitter display (SED), laser television, carbon nanotubes, quantum dot display, interferometric modulator display, or any other suitable equipment for displaying visual images. In some embodiments, display 104 may be HDTV-capable. In some embodiments, display 104 may be a 3D display, and the interactive media application and any suitable content may be displayed in 3D. A video card or graphics card may generate the output to the display 104. The video card may offer various functions such as accelerated rendering of 3D scenes and 2D graphics, MPEG-2/MPEG-4 decoding, TV output, or the ability to connect multiple monitors. The video card may be any processing circuitry described above in relation to control circuitry 107. The video card may be integrated with the control circuitry 107. User devices 116 and 118 each include displays similar to display 104.

Computing device 110 runs a synchronization application and stores the object data model 112 which represents a state of a presentation generated for display on display 104. The synchronization application may aggregate user participation analytics and/or user engagement analytics (e.g., annotations, highlights, notes, and/or questions) to store with the object data model 112. The synchronization application may be the content sharing software application referred to as the “application” in FIG. 3 below. Alternatively, the synchronization application on the computing device may be a variant of the application. The application may have the same layout on various different types of user equipment or may be tailored to the display capabilities of the user equipment. For example, on computing device 110, the application may be provided with different features or may be a web site accessed by a web browser. In another example, the application may be scaled down for wireless user devices.

The synchronization application may be implemented using any suitable architecture. For example, it may be a stand-alone application wholly-implemented on the computing device 110 and the user devices 116, 118. In such an approach, instructions of the application are stored locally and data for use by the application is downloaded on a periodic basis (e.g., from an out-of-band feed, from an Internet resource, or using another suitable approach). Control circuitry 107 may retrieve instructions of the application from storage 105 and process the instructions to generate any of the displays discussed herein. Based on the processed instructions, control circuitry 107 may determine what action to perform when input is received from input interface 102. For example, movement of a cursor on a display up/down may be indicated by the processed instructions when input interface 102 indicates that an up/down button was selected.

A state refers to all stored information, i.e., the contents of all memory locations, at a given instant in time and a current state of a data model refers to a current set of values for the attributes of the object data model.

For example, presentation information stored in object data model 112 may include data included by the presenter on the slides, with any associated formatting or effects. Presentation information in object data model 112 may also include information regarding the delivery of the presentation. For example, presentation information in object data model 112 may include the number of total slides, an indication of the time spent on each slide by the presenter, an indication of engagement or participation by users, an indication of the time marker at which the presenter moves forward in the slides, and fields to indicate whether certain animations are taking place, and at what time. Presentation information may include segmented content that has been divided during a segmentation process according to a percent of change occurring on a screen of a presenter. Presentation information may include audio data generated by the media content or by the presenter via a microphone. The audio content may be synced with the segmented content.

When the state of the presentation changes, for example when a presenter at computing device 110 uses the user input interface 102 to change slides in the presentation, control circuitry 107 and processing circuitry 106 update object data model 112 in the computing device 110. When the content changes from a first segment to a second segment (e.g., the screen changes a predetermined threshold percentage), the processing circuitry 106 may update the object data model 112 to indicate the change. When a segment of content receives a highlight, an annotation, a note, or a question, the processing circuitry 106 may update the object data model 112 to include the highlight, annotation, note, or question.

Processing circuitry should be understood to mean circuitry based on one or more microprocessors, microcontrollers, digital signal processors, programmable logic devices, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), etc., and may include a multi-core processor (e.g., dual-core, quad-core, hexa-core, or any suitable number of cores) or supercomputer. In some embodiments, processing circuitry may be distributed across multiple separate processors or processing units, for example, multiple of the same type of processing units (e.g., two Intel Core i7 processors) or multiple different processors (e.g., an Intel Core i5 processor and an Intel Core i7 processor). In some embodiments, control circuitry 107 executes instructions for an application stored in memory (i.e., storage 105). Specifically, control circuitry 107 may be instructed by the application to perform the functions discussed above and below. For example, the application may provide instructions to control circuitry 107 to generate displays. In some implementations, any action performed by control circuitry 107 may be based on instructions received from the application. Control circuitry 107 described herein may be implemented using software running on one or more general purpose or specialized processors.

An application may be, for example, a stand-alone application. For example, an application may be implemented as software or a set of executable instructions which may be stored in storage, and executed by control circuitry of a user device. In some embodiments, applications may be client-server applications where only a client application resides on the user equipment device, and server application resides on a remote server. For example, applications may be implemented partially as a client application on control circuitry of a user equipment device and partially on a remote server as a server application running on control circuitry of the remote server. When executed by control circuitry of the remote server, the server application may instruct the control circuitry to generate the application displays and transmit the generated displays to the user equipment devices. When executed by control circuitry of the remote server, the application may instruct the control circuitry to transmit data for storage on the user equipment. The client application may instruct control circuitry of the receiving user equipment to generate the application displays.

The application and/or any instructions for performing any of the embodiments discussed herein may be encoded on computer readable media. Computer readable media includes any media capable of storing data. The computer readable media may be transitory, including, but not limited to, propagating electrical or electromagnetic signals, or may be non-transitory including, but not limited to, volatile and non-volatile computer memory or storage devices such as a hard disk, floppy disk, USB drive, DVD, CD, media cards, register memory, processor caches, Random Access Memory (“RAM”), etc.

In FIG. 1, when the computing device object data model 112 is updated, the control circuitry 107 sends update information from the computing device 110, through network connection 114, to an API server 122. Update information includes presentation information retrieved by the synchronization application and stored in an object data model form. In an exemplary embodiment, the API server 122 is a remote server, and the one-way synchronization between the computing device 110 and the API server 122 is performed at fixed time intervals. In an alternative embodiment, synchronization may be two-way synchronization, in the event that a backup may be retrieved from the API server 122 to restart a presentation at the last played position on computing device 110. Transfer of data from the computing device 110 to the API server 122 may be done via network connection 114 which may be a network server such as a Wi-Fi or cellular network.

A network connection such as network connection 114 may include communication paths which couple user equipment devices and the computing device directly or indirectly. The network connection may use one or more networks including the Internet, a radio communications network, a mobile phone network, mobile voice or data network (e.g., a 4G or LTE network), cable network, public switched telephone network, or other types of communications network or combinations of communications networks. Communication paths may separately or together include one or more communications paths, such as, a satellite path, a fiber-optic path, a cable path, a path that supports Internet communications (e.g., IPTV), free-space connections (e.g., for broadcast or other wireless signals), or any other suitable wired or wireless communications path or combination of such paths. Communication paths may also include other short-range point-to-point communication paths, such as USB cables, IEEE 1394 cables, wireless paths (e.g., Bluetooth, infrared, IEEE 802-11x, etc.), or other short-range communication via wired or wireless paths. BLUETOOTH is a certification mark owned by Bluetooth SIG, INC.

Requests, commands and other suitable data may be sent using control circuitry. An input/output path may connect control circuitry to one or more communications paths.

In the embodiment of FIG. 1, as the presenter moves through a presentation or display of a media asset at computing device 110, the synchronization application updates the object data model to reflect the current state of the presentation, and periodically and frequently transfers updates from this source object data model to a remote API server. In an exemplary embodiment, the synchronization application may automatically store information on the status of the ongoing presentation or media display. In an alternative embodiment, a manual override may be used to update the information at the API server when requested by the presenter.

In turn, the API server 122 pushes updates down to user equipment devices 116 and 118 which store local object data models 117 and 119 respectively. To receive updates, user equipment devices request a star network connection with the API server 122 and when a connection is established, the API server pushes down updates to the local object data model. When no star network connection can be established with the API server 122 (e.g., connection failure or time out) each user equipment device requests a mesh network connection with at least one other user device. In the embodiment of FIG. 1, user device 116 and user device 118 are both part of mesh network 120. When user device 118 has established a star network connection with API server 122 but user device 116 has been unable to do so, user device 116 can connect via mesh network 120 to user device 118. Accordingly, user device 116 can receive periodic updates to its local object data model updates from user device 118.

The method shown in FIG. 2 can be implemented with system 100 described in FIG. 1. Method 200 or any step thereof can be performed on, or provided by, any of the devices shown in FIG. 1. For example, process 200 may be executed by control circuitry 107. In FIG. 2, at step 202 an object data model representative of a state of a presentation is stored in computing device. At step 204 the method monitors the presentation for a change in state. At step 206 when a change in state is detected the method proceeds to step 208. When a change in state is not detected, the method returns to step 204 and continues monitoring the presentation for changes in state. At step 208, the method updates the object data model stored in the computing device. Updating the object data model requires a limited amount of data transfer, comprising only values of fields that have been updated, such as current slide number and slide status, thereby minimizing the load on the network used. At step 210, the method sends update information from the computing device to an API server (for example, API server 122 in FIG. 1). At step 212, the method requests a star network connection between the API server (for example, API server 122 in FIG. 1) and a first user device (for example, user device 116 in FIG. 1). At step 214, the method determines whether the star network connection was successful. When the star network connection was successful, the method proceeds to step 216, where updates are pushed from the API server to the first user device to update a local object data model (for example, object data model 117 in FIG. 1) of the first user device. When the star network connection was unsuccessful, the method proceeds to step 218, which requests a mesh network connection between the first user device and a second user device (for example, user device 118 in FIG. 1). At step 220 the method updates a local object data model of the user device by pushing updates from the second user device. At step 222, following either step 216 or steps 218 and 220, content is synchronously shared between the computing device (for example, computing device 110 in FIG. 1) and the first user device (for example user device 116 in FIG. 1).

The method shown in FIG. 3 can be implemented from system 100 described in FIG. 1. Method 300 or any step thereof can be performed on, or provided by, any of the user devices shown in FIG. 1. In this embodiment, a user or conference attendee accesses a content sharing software application, referred to as the “application.” The application can be loaded onto a user's tablet or computing device. In the embodiment of FIG. 1, the application is implemented on user devices 116, 118 and on computing device 110. The application may be a standalone application or a web browser plugin, which communicates with the computing device 110, as shown in FIG. 1. Conference provided tablets can be offered to conference attendees with the application already pre-loaded. Alternatively, attendees may download the application on their personal computer or tablet prior to the conference. The application may include data and data structures provided by API server 122 ahead of the presentation. The application allows users to follow along a presentation, synchronized with the presenter. The application may work with multiple operating systems. In an exemplary embodiment the software application may be inherent to the operating system.

At step 302, a user opens the application on a user device (for example, user device 116 in FIG. 1). A user, for example a conference attendee may download the application through an application aggregator, such as the Apple App Store. The application is available for operating systems iOS7 and higher, as well as Android platforms. In alternative embodiments, students can access lecture content, and users can access publicly available content through the presentation application.

Users with the application on their devices may open up the application when attending a conference, or when intending to access a specific content.

In the embodiment of FIG. 3, when a user opens the application, the application may first automatically attempt to scan for known star networks, and concurrently automatically query peers to create a mesh network. In the discovery phase, the application on a local user device identifies potential mesh peers by using criteria such as closeness, signal strength, preferences, or other factors. U.S. Pat. No. 7,277,950 incorporated herein describes mesh peer selection.

In the embodiment of FIG. 3, the application may include in memory at least an object data model for the media asset the user intends to access. For example, the application may include in memory at least an object data model for the presentation the user is attending. The application may obtain an object data model for a presentation based on user selection, or according to additional information such as conference schedule and user location. For example, within the application, a user may select through an interface a conference type ‘Medical’, further select ‘American Obstetrical Institute’ and a date ‘Day 1’ to select the presentation ‘Keynote Address.’ For example, the user device may detect user location based on GPS information, or IP address.

After a user opens the application on a user device (for example, user device 116 in FIG. 1) at step 302, the application proceeds to step 304 and queries the network connection (for example, network connection 114 in FIG. 1) to determine if there is a connection between the user device and an API server (for example, API server 122 which has been updated with information regarding the object data model of computing device 110 in FIG. 1). At step 312, the application determines if the connection is a success. When the connection is a success, the application proceeds to step 318. At step 318 the application updates the local object data model for the user device with information from the object data model of the source device.

When a user device is unable to query the API server, it may query users in the pre-established peer network, as described below. When the application determines at step 312 that the connection is a failure (for example, failure of the star network connection between user device 116 and API server 122 in FIG. 1), the application proceeds to step 314. When a user connection through the star network fails, the network stack returns an exception indicating that the network is not available as a transport layer that can be used for requesting data. Once such a network request fails, the network stack returns an exception. The application receives that exception. A connection may be a technical failure when after a finite amount of time no connection has been established or a connection is determined to be insufficient to support the desired data transfer operations. For example, a connection may be a failure when no network available, there is no route to host, a bad gateway, access points overload, inability to generate an IP address, inability to meet safety protocols, or a timeout resulting from a slow bandwidth. In the event that the nature of the actual technical failure is unknown, the application may still act on that failure by accessing the mesh network to make its next request. In response to a failover event, a request may be made on the mesh network for the next slide in the presentation.

In the embodiment shown in FIG. 3, the application may transition to the mesh network to maintain synchronous delivery of content to the user. As noted above, a request to connect to the server may fail due to there being no network available, no route to host, a bad gateway, access points overload, inability to generate an IP address, inability to meet safety protocols, or timeout resulting from a slow bandwidth. In the event that the nature of the actual technical failure is unknown, the application may still act on that failure by accessing the mesh network to make its next request.

When a device is unable to find a responsive peer in the network with the appropriate object data model, the device continues to query the peers in its mesh network. Similarly, every user device may query peers in its respective mesh network. When every user device is querying peers and some peers are connected to the API server, the initial query user will eventually, after a finite period of time and a finite number of hops, obtain the update information to update its object data model. In an exemplary embodiment, a user may query peers within its immediate mesh network every 30 seconds. Once a user receives the updated object data model, the application propagates the object data model to peers within its immediate mesh network.

The application may perform step 306 in parallel with step 304. At step 306 the application queries peer users. At step 308, the application applies peer user conditions. At step 30, the application establishes a mesh network by connecting to peer users according to peer user conditions. For example, each user may set preferences regarding the type of network the characteristics of users it will accept within its mesh network. Some users or user devices may screen members of mesh networks based on IP address, name, storage space, or any other combination of characteristics. The application may also restrict the type of application users selected for a mesh network by requiring that the selected peers have the object data model associated with the ongoing presentation. The application also ensures that peers are sharing the same presentation. The application may perform a check during peer negotiation that all peers have a common object data model specific to a shared presentation, for example as determined by a document ID field. A check for a shared object data model to be used minimizes interferences between presentation data being broadcasted by mesh network nodes in different conference rooms which may be adjacent.

Any device on a mesh network gets the updated object presentation model. Once a connection is established as determined at step 312, each user device may automatically and periodically broadcast its local version of the object data model to peer users and to the network. Each user device running the application compares its local and current object data model to the most recently received object data model for the ongoing presentation. To compare the local and current object data model, a user device may check each field in the object data model. When a field in the object data model has a different value in the local object data model and in the current object data model, this indicates that the local object data model is not current and an update is required. In some examples, the presenter may control which device receives a particular update of the updated object presentation model. For instance, the presenter may control which devices receive synchronized audio data corresponding to the updated presentation model.

Periodic occurrences such as periodic broadcasts, periodic pushes or pulls of update information may be occurrences which take place repeatedly at fixed and equal time intervals. These time intervals or a corresponding frequency of occurrence may be automatically set by the system or a device, or set by the user. For example, periodic broadcasts described above may take place every second, every 30 seconds, or every 2 minutes.

In some examples, a presenter may indicate or select a particular device or user to receive a particular type of update, while indicating that other devices or users are not to receive the update. For instance, the presenter may select a particular device to receive audio data (e.g., which may be synchronized with the presentation or other content being presented) while other devices do not receive the audio data. As such, the presenter may enable a private conversation with the particular device during the presentation that the other devices do not receive. The audio data may have a destination address corresponding to the particular device such that the audio data may be transmitted via the star and/or mesh networks of the other devices, but only be accessible once the audio data reaches the particular device associated with the destination address. In some examples, the presenter may cause only the particular device to access the audio data by distributing commands to the other devices, via model updates sent via the star or mesh network, causing the other devices to mute the speakers at the other devices for a duration of one or more segments.

As described above, based on the object data model comparison, each peer user device may determine whether they need to update the local object data model. For example, a user device can make a request on the mesh network for the URI or new slide it needs to be consistent with the newest version of the object presentation model. In this embodiment, each user device connected to the computing device may execute a series of push and pull instructions, configured to broadcast or receive updates to the object data model. Accordingly, each user device may periodically receive from the computing device of the presenter an update to its local object data model, transferred via the API server either directly to the user device, or through a peer in a local mesh network.

Updating the object data model requires a limited amount of data transfer, comprising only values of fields that have been updated, such as current slide number and slide status, thereby minimizing the load on the network used. For example, the only data required by a peer may be the value of the field in the object data model indicating the current slide number, URI or the ID for the current slide.

In some embodiments, an application client residing on the user's equipment send requests to obtain data when needed, e.g., when updates are required or when the user equipment device receives a request from the user to receive data. Updates may be provided to the user equipment with any suitable frequency (e.g., continuously, daily, a user-specified period of time, a system-specified period of time, in response to a request from user equipment, etc.). The frequency may be automatically set, or set by the user.

At step 314, the application pulls object data model information from another user. device in the mesh network (for example user device 118 in mesh network 120 in FIG. 1). At step 316, the application pushes object data model information to another user device in the mesh network (for example user device 117 in FIG. 1 can push updated object data model information to another user device in the mesh network). At step 320, synchronization is a success, with information being synchronously shared between the user device and a computing device, either via an API server star network connection, or via a mesh network connection.

With the application implemented on system 100 in FIG. 1, when a presenter using computing device 110 to generate for display a presentation on display 104 changes slide, the slide displayed on the user device for a synchronized user device changes. A group of remote users may also receive synched audio data (e.g., generated in real-time during the presentation by a microphone at the computing device 110) through the application. In addition, with the application, a presenter and users may highlight, annotate, take notes, or ask questions for each slide with text or figures. In an exemplary embodiment, users may bookmark slides, and submit comments. In the embodiment of FIG. 1, a user can draw on a touch screen tablet a schematic, or type an annotation, which is saved with the slide presented at the time of the annotation. Comments may be shared with the presenter, a specific user, or groups of users, or saved for future reference. For segmented content, the highlights, annotations, notes, and/or questions may be associated with the segment and/or aggregated by segment to generate participation analytics. For example, the presenter can engage with the audience by requesting feedback which can be stored and analyzed. Users may save their annotated slide set for future reference. U.S. Pat. No. 7,373,590, incorporated by reference describes a slide annotation application.

In some examples, the content (e.g., segmented content), such as the presentation, may include a notes section, which the presenter may cause to be opened or closed via one or more commands. When opened, the note taking section may receive notes from any of the users receiving the content, and the notes may be updated to other users and/or the presenter by updating the object data model 112. The content may receive annotations and highlights from the users. For instance, a user may select a color and a pen or highlighter to mark sections directly on material being presented on a user device. The annotations or highlights may be updated to other users and/or the presenter by updating the object data model 112. In some instances, users can ask questions to the presenter during the presentation and/or after the presentation. The questions may be updated to the other users and/or the presenter by updating the object data model 112, however, a name of the user submitting the question may be removed from the update for anonymity. In some instances, another user may “up vote” a question if the other user has the same question, and the up votes may be updated to the other users and/or the presenter. The application may present a questions menu item at a dashboard of the presenter so that the presenter can see the questions and up votes and provide a response to the question. The response to the question may be updated to the users by updating the object data model 112. Moreover, in some instances, the questions and/or the response may be associated with a particular segment of content at which the question was asked, and may be presented at a user dashboard on the user device. A recording of the presentation (or other shared content) with audio data created during the presentation may be generated and/or stored in a data file smaller than a video file, saving storage space and costs for storage.

In some instances, the application may perform analytics on a presentation or other shared content. The analytics may be performed according to the segmentation process such that data is generated and aggregated for each segment (e.g., slide, screen, video scene, etc.) of the presentation or other shared content. As noted above, the segmentation process may break down or divide the presentation or other content based on detecting a change on a screen (e.g., at the presenter device or the user device) and determining that the change on the screen is greater than a percentage of change threshold value. As such, engagement analytics may include a rate of notes, an amount of notes, an indication of particular words included in notes, an annotation rate, an amount of annotations, a view rate, an amount of views, and/or an indication of highlighted words for a particular segment, multiple segments, or the entire presentation or other shared content. In some instances, a screen capture of the particular segment may be stored and presented with the analytics generated for the particular segment. In some examples, the presentation may include a live poll at a particular segment. The presentation may be recorded and stored for post playback. During post playback, an identity of a user or user device viewing the post playback may be determined. If the application determines that the user or user device did not view the presentation during the original live sharing (e.g., the post playback is a first time of viewing for the user), the application may omit results of the poll so that the user may take the poll as if it were a first time viewing or taking the poll.

FIG. 4 depicts a schematic of a star network 400 in which network hub 407 is in direct communication with a number of nodes 401-406 (users 1, 2, 3, N, N+1, and N+ . . . ). The direct connections between hub 407 and nodes 401-406 are referred to herein as a one-hop communication. For example, User 1 (401) is one-hop removed from the Network connection (407), which itself is only one-hop removed from an API server (409).

As referred to herein, a star network is a local area network (LAN) in which all nodes (user equipment devices, any other devices) are directly connected to a common central computer, e.g., the computing device. Every user equipment device is indirectly connected to every other user equipment device through the central computing device. In some embodiments, the computing device can also operate as a user equipment device.

In some embodiments, a request for a star network connection may be automatic or transparent to the user. In alternative embodiments, the request for the star network connection may require user input. Requests may be sent from a user equipment device to a server remote from the user equipment device.

FIG. 5 depicts a schematic of a mesh network 500 which includes both star network properties, and mesh network properties. A mesh network may be a local area network (LAN) that employs one of two connection arrangements, full mesh topology or partial mesh topology. A mesh network topology is a decentralized design in which each node on the network connects to at least two other nodes such that there is no single point of network failure. As referred to herein, a network failure may be at least one of request time out, bad gateway, and a no host error. If one node can no longer operate, the rest of the nodes can still communicate with each other, directly or through one or more intermediate nodes. In a full mesh topology, each network node is connected to all the other nodes in the network. In a partial mesh topology, at least one node connects directly to every other node while others may only connect to those nodes they exchange data with on a frequent basis.

Users may access the media asset through a star network by connecting their devices to the remote API server via a standard internet connection, Wi-Fi, or cellular. As shown in FIG. 5, User 2 (502) may connect to the API server via the hub network connection. Similarly, User 3 (503) in FIG. 5 may access the API server through a one-hop connection. The presenter or source device in FIG. 5 may also upload to the API server through a one-hop connection via the hub network, as shown in the embodiment of FIG. 1. Alternatively, the presenting device or computing device is not part of a mesh network. Instead, the computing device is connected to the API server via a star-type network, such as a Wi-Fi network. In an alternative embodiment, the computing device may be connected to other devices through mesh-type networks.

Once open, for example at step 302 of FIG. 3, the application may automatically search for available networks, both so-called star networks such as a Wi-Fi networks or cellular networks; and peer based so-called mesh networks. In an alternative embodiment, a user may set preferences regarding the type of network and in the case of a mesh network, the characteristics of users it will accept within its mesh network. When a user device is part of a system as shown in FIG. 5, which includes both a star network, and multiple overlapping mesh networks, User 3 is a part of the star network, having a direct one-hop connection to the API server. User 3 is also a part of a first mesh network including Users 1, 2 and 3, and User 3 is part of a mesh network including Users 3, N, N+1 and N+ . . . .

As shown in FIG. 5, users 503-506 are nodes which are in communication with each other within a mesh network. The direct connection between node 501 and 502 or between 503 and 505 is also referred to as a one-hop connection. The indirect connection between nodes 502 and 506 is referred to as a two-hop connection, and connections can include more than two hops. As shown in FIG. 5, some users, such as User 3 (503) may be connected both directly to the network connection (507) and to users not directly connected to the network (504-506). For example, User N (504) is connected to the network connection through User 3 (503) or a chain of users (506, 505, 503) to the network connection (507). Users may access the media asset through a star network by connecting their devices to the remote API server via a standard internet connection, Wi-Fi, or cellular. User 2 (202) may connect to the API server via the hub network connection. Similarly, User 3 (203) in FIG. 5 may access the API server through a one-hop connection. The presenter or source device in FIG. 5 (for example computing device 110 in FIG. 1) may also upload to the API server through a one-hop connection via the hub network.

FIG. 6 depicts a schematic of an embodiment of the system where both a star network and a mesh network may coexist. Conference attendees with tablets may have access to the internet provided by the conference organizer or venue hosts, either through a cellular connection, 3G, 4G, Wi-Fi connection or otherwise, and are therefore able to directly connect to the same server as the presenter. Through a one-hop connection to the server, conference attendees may receive synchronized data from the presenter. In the embodiment shown in FIG. 6, Users 1, N and N+1 (601, 605 and 604) may be part of a mesh network, whereas User N+(606) may be connected to the network (607) through a star structure. In FIG. 6, the Application Server (609) may be connected to the network through this star structure. A presenter (608) may have a computing device directly connected to the Network (607), and the computing device may include or interact with both an automator or synchronization tool (610) and a manual override tool or option (611).

FIG. 7 depicts a schematic representation of an exemplary data model structure. As shown in FIG. 7 the data structure may include structure metadata (e.g. F1 in FIG. 6), such as title, version, date, etc. For example, as shown in FIG. 7, F1 includes an ID field, along with an attributes field, which may further include, theme, location and summary, for example. The data structure may also include attribute metadata, such as name, description, data type, variable type, number type, criteria. For example, as shown in FIG. 7, the data structure includes fields such as current slide, speaker or moderator. Finally, the data structure may also include data and flag arrays for each attribute. For example, in FIG. 7, block F2 includes data or flag values to the attributes. For example, the field ‘Number’ is associated with the attribute ‘CurrentSlide’ and the attribute hasSlides' is associated with the flag ‘boolean’.

FIG. 8 depicts a schematic of an exemplary embodiment of the system. In this embodiment, at a conference center, or in a school setting, presentations may take place in nearby or adjacent locations. A first presenter, Presenter A may give a presentation in presentation room A, whereas next door, presenter B may give a presentation in presentation room B. As shown in FIG. 6, each presenter may use a computer with an automator, and may communicate through a Wi-Fi network to the internet. For example, Presenter A, and participants in room A use Wi-Fi network A, whereas Presenter B, and participants in room B may use Wi-Fi network B. Alternatively, participants may also connect to the internet via a cell network. In an exemplary embodiment, access to the internet provides access to the ConferenceNotes server.

As shown in the exemplary embodiment of FIG. 8, participant devices may be connected directly to the Wi-Fi network, such as A1, A6, A7 and A9. For example, A1 and A7 are only connected to the Wi-Fi network, and not to other devices. In contrast, device A6 is connected to Wi-Fi network A, but is also simultaneously connected to devices within a mesh cluster comprising devices A5, A4, A3 and A2. Device A4 is indirectly connected to the Wi-Fi network A through devices A5 and A6. Furthermore, some devices may be connected to multiple clusters. For example, user device A4 shown in FIG. 6 is part of a first mesh cluster (A2-A6), and part of a second mesh cluster (A8-A10).

As shown in FIG. 8, connections in adjacent rooms, such as presentation room B, may function in a similar manner, with devices such as B5 connected directly to the internet, through the cell network in the case of B5, or through Wi-Fi, in the case of B9. In addition, connections may also be established directly and/or indirectly through other devices within a mesh. Clusters may communicate through bridge devices. For example, in presentation room B, devices B6 and B3, located in distinct clusters, may communicate.

In an exemplary embodiment, there is no communication between users in presentation room A and in presentation room B. In an alternative embodiment, users may connect with mesh networks in a different location. For example, a conference having several identical sessions for a same presentation may allow users located in different sessions to connect.

In an exemplary embodiment, the application may establish a mesh network without any indication to the user of the mesh build up process. In an alternative embodiment, the application may request the user to select whether the device will query peers to create a mesh network, and whether the user device itself will be available for outside requests to join mesh networks.

In determining which users may qualify as active peers within a mesh network, factors such as randomness, preferences, system resources and past user history may be under consideration. In an exemplary embodiment, the application on a user device may maintain a list of peer devices located within the established local network. This peer device list may be stored in a database on a memory of the user device. In an alternative embodiment, the peer device list may be stored remotely. The peer device may be periodically updated to reflect whether peers have recently entered or exited the pool of available peers for local mesh network selection.

In an exemplary embodiment, a device may be a participant in multiple mesh networks. A mesh network may be an aggregate of smaller local mesh networks, with the smaller mesh networks overlapping by at least one device. In an exemplary embodiment, a local mesh network may include between three and eight devices. In a preferred exemplary embodiment, a local mesh network may include four devices to minimize bandwidth overhead. In an exemplary embodiment, as many as four hundred devices or greater may be connected.

In an exemplary embodiment, considerations of media asset size and network efficiency may determine the means through which information is disseminated between users. For example, media assets may be transferred between peers of a local mesh network, through a one-hop process, whereas synchronization indicators stored in the object data model, such as number of the currently active slide, may be transferred through one-hop or multiple hop processes, since the transfer requires less resources.

Push and pull processes, together with pinging of peer devices may become a load on the server. Minimizing the amount of information transfer required to synchronize users with the source device, through the user of the object data model optimizes the use of the mesh network. In an exemplary embodiment, pull requests are performed in a synchronized way across all user devices. In an exemplary embodiment, as noted above, in the event of a failure to connect, the system provides a failover synchronization between devices, which may be a peer to peer synchronization using peer devices accessible within pre-established mesh networks.

In an exemplary embodiment, while a presenter device streams a media asset such as a presentation, the synchronization tool on the source device periodically updates its object data model to reflect the state of the presentation, and uploads it to the remote API server through a star network. User devices connected to the network periodically query the API server through the star network and update their local object data models.

In the event of a conflict between multiple peers in a mesh network or between peers in the mesh network, the values of the fields stored in the current object data model on the API server prevail.

FIG. 9 depicts steps for a general request for an object data model according to an exemplary embodiment. At step 902, a user device initiates a request for a data structure or data model. At step 904 the user device determines the status of the request (904), which is either a success (906) or a failure. In the event of a request failure, the user device proceeds to step 908 and queries whether the data model may be obtained through a mesh (908), leading either to a determination that the data model is not available via mesh (910), or leading to a request being sent to the mesh controller (912).

FIG. 10 depicts steps for an object data model request from a mesh network according to an exemplary embodiment. Once a mesh request is initiated at step 1002, at step 1004 a check is performed by the user device to determine whether the user has peers, in which case the data model request may be sent to peers (step 1006). In the embodiment of FIG. 10, once data is received from the peers at step 1008, a check is performed by the user device to determine whether the request is complete (step 1010). In the event that the request is complete, the local data model is notified at step 1014. In a non-limiting embodiment, notification of the local data model includes an updated of the fields in the local data model, which may be replaced with data obtained from the data model received from peer devices. In the event that the request at step 1010 is determined to not be complete, a wait time may be built in at step 1012 before returning to step 802 to perform a new check and determine whether peers are available.

FIG. 11 depicts steps for a mesh management scheme according to an exemplary embodiment. In the embodiment of FIG. 11, an iOS meshing framework may enable users to start advertising at step 1106 and receive an invitation (step 1108) to a mesh network.

Alternatively, an iOS meshing framework may enable users to start browsing at step 1116 and at step 1118, determine whether peers are found. An iOS meshing framework may also, in a non-limiting embodiment, allow users to accept or decline invitations (steps 1112 and 1114), to send invites (steps 1124) and to check the connection status with peers (step 1126), as well as providing an end to the browsing for peer devices (step 1130). Alternatively, the application may make the decision to start a mesh network (step 1102) and decide whether the user device on which the application is running will browse or advertise for updates (step 1104).

For example, a user device which is determined to not have performed an update of the object data model for a relatively long period of time may be selected to advertise, e.g. to circulate a request to join a mesh network to obtain the opportunity to update its local data structure. Alternatively, if a user sets a preference setting to have manual control over the formation of mesh networks, a user device may be selected to browse for peers. In an exemplary embodiment, the application may display a list of available peers. Available peers may be ranked based on a set of criteria such as proximity, signal strength, or past history.

As shown in FIG. 11, once an invitation is received by a device, the application may determine whether the maximum of connections established between the user device and other devices in the mesh is reached (step 1110) and either accept invitations at step 1114 or decline invitations at step 1112. Alternatively, once at least one peer has been found at step 1118, the application may make a determination at step 1120 of whether or not an invite should be sent to the detected peer. At step 1122, the application may make a determination to ignore the detected peer. At step 1128, the application may also determine whether a maximum number of connections between the user device and peer devices have been reached. In the event that the number of connections is reached, and the iOS structure determines to stop browsing at step 1130, the application may set conditions for starting to browse peers again. In the embodiment of FIG. 11, the application may include a wait period, such as 20-50 seconds at step 1132 before returning to step 1116 to browse.

FIG. 12 depicts an example method 1200, which may be performed by any of the systems discussed herein, for sharing audio data with a selected user. At step 1202, the method 1200 may include sending update information from the computing device 110 of a presenter to a first user device (e.g., the user device 116) to update a user object data model (e.g., object data model 117) at the first user device. At step 1204, the method 1200 may include selecting, at the computing device 110, a second user device (e.g., the user device 118) for receiving audio data (e.g., which may be synched with presentation data). At step 1206, the method 1200 may include sending the audio data from the computing device 110 to the first user device. At step 1208, the method 1200 may include preventing the first user device from outputting the audio data. At step 1210, the method 1200 may include sending the audio data from the first user device to the second user device (e.g., via the mesh network). At step 1212, the method 1200 may include outputting the audio data at the second user device.

FIG. 13 depicts an example method 1300, which may be performed by any of the systems discussed herein, for generating the source object data model. At step 1302, the method 1300 may include extracting data from a web browser, a slideshow, a video, and/or an application operating on the computing device 110 of the presenter. At step 1304, the method 1300 may include presenting an indication of the data on the computing device 110 as a drop-down menu. At step 1306, the method 1300 may include receiving a user input selecting the indication of the data. At step 1308, the method 1300 may include generating a source object data model (e.g., the object data model 112) based on the data and in response to the user input. At step 1310, the method 1300 may include sending update information corresponding to the source object data model to at least one user device for synchronized content sharing.

FIG. 14 depicts an example method 1400, which may be performed by any of the systems discussed herein, for synchronizing content sharing between the computing device 110 and one or more user devices. At step 1402, the method 1400 may include determining content stored at the computing device 110 of the presenter. At step 1404, the method 1400 may include performing a segmentation process on the content to divide the content into a plurality of segments based on a percent of a visual presentation of the content that changes. At step 1406, the method 1400 may include sharing the plurality of segments with at least one user device as update information for updating a user object data model at the at least one user device. At step 1408, the method 1400 may include receiving, at the at least one user device, a user engagement item including an annotation, a highlight, a note, or a question associated with a particular segment of the plurality of segments. At step 1410, the method 1400 may include updating, at the computing device 110 of the presenter, a source object data model to include the user engagement item associated with the particular segment. At step 1412, the method 1400 may include updating, at the computing device 110 of the presenter, the source object model to include a response to the user engagement item. At step 1414, the method 1400 may include sending update information from the computing device 110 of the presenter to the at least one user device to update a user object data model to include the response associated with the particular segment.

It is to be understood that the specific order or hierarchy of steps in the methods depicted in FIGS. 2, 3, and 12-14 are instances of example approaches and can be rearranged while remaining within the disclosed subject matter. For instance, any of the steps depicted in FIGS. 2, 3, and 12-14 may be omitted, repeated, performed in parallel, performed in a different order, and/or combined with any other of the steps depicted in FIGS. 2, 3, and 12-14. 

What is claimed is:
 1. A method for synchronous content sharing, the method comprising the steps of: updating, in a computing device, a source object data model in response to a change in a media asset to yield an updated source object data model, the updated source object data model identifying the media asset to be synchronized and an element of the media asset displayed by the computing device; sending update information from the computing device to a server to cause at least one user device to update a user object data model stored at the at least one user device; and updating the user object data model by pushing updates to the user object data model from the server to the at least one user device.
 2. The method of claim 1, wherein the update information causes the at least one user device to receive and output audio data and a second user device to be prevented from outputting the audio data.
 3. The method of claim 1, wherein: the at least one user device includes: a first user device with a first user object data model stored at the first user device; and a second user device with a second user object data model stored at the second user device; and pushing the updates is performed for all user devices connected to the server.
 4. The method of claim 3, wherein the update information causes the first user device to distribute audio data generated at the computing device to the second user device and prevents outputting the audio data at the first user device.
 5. The method of claim 3, further comprising: sending the update information from the first user device to the second user device to cause the second user device to update the second user object data model stored at the second user device, the first user device communicatively coupled with the second user device; and updating the second user object data model by periodically pushing the updates to the second user object data model from the first user device.
 6. The method of claim 5, further comprising receiving, at the computing device, a selection of the second user device, wherein the update information includes audio data to be outputted at the second user device, based at least partly on the selection, and prevented from being outputted at the first user device.
 7. A computing device for synchronous content sharing, the computing device comprising: a processor; and a memory configured to store instructions that, when executed by the computing device, cause the computing device to: update, in the computing device, a source object data model in response to a change in a media asset, the source object data model including at least an identification of the media asset to be synchronized and an identification of an active element of the media asset currently displayed by the computing device; send update information from the computing device to a server to cause at least one user device to update a user object data model stored at the at least one user device; and update the user object data model by pushing updates to the user object data model from the server to the at least one user device.
 8. The computing device of claim 7, wherein the instructions further cause the computing device to generate the source object data model by: extracting data from an application operating on the computing device; presenting an indication of the data from the application; and receiving a user input selecting the indication of the data from the application.
 9. The computing device of claim 8, wherein presenting the indication of the data from the application includes presenting a drop down menu listing the data from the application.
 10. The computing device of claim 7, wherein the instructions further cause the computing device to generate the source object data model by performing a segmentation process on content stored at or being presented by the computing device.
 11. The computing device of claim 10, wherein the segmentation process includes dividing the content into a plurality of segments based at least partly on a percent of a visual presentation of the content that changes.
 12. A method for synchronous content sharing comprising: updating, in a computing device, a source object data model in response to a change in a media asset; sending the source object data model from the computing device to a server to cause a first user device to update a first user object data model stored at the first user device; updating the first user object data model by pushing the source object data model to the first user device; sending the first user object data model from the first user device to a second user device to cause the second user device to update a second user object data model stored at the second user device; and updating the second user object data model by pushing the first user object data model to the second user device from the first user device.
 13. The method of claim 12, wherein the change in the media asset includes a note generated at the first user device or the second user device and in a note section associated with the media asset.
 14. The method of claim 12, wherein the change in the media asset includes a highlight or an annotation generated at the first user device or the second user device.
 15. The method of claim 12, wherein the change in the media asset includes a question generated at the first user device or the second user device.
 16. The method of claim 15, wherein updating the source object data model includes generating, at the computing device, a response to the question.
 17. The method of claim 12, further comprising performing a segmentation process on the media asset to divide the media asset into a plurality of segments.
 18. The method of claim 17, wherein updating the source object data model includes updating a particular segment of the plurality of segments represented by the source object data model.
 19. The method of claim 17, wherein: updating the first user object data model includes updating a particular segment of the plurality of segments represented by the first user object data model; and updating the second user object data model includes updating the particular segment of the plurality of segments represented by the second user object data model.
 20. The method of claim 12, further comprising: detecting a user engagement with the first user object data model or the second user object data model; and sending an indication of the user engagement from the first user device or the second user device to the computing device. 